Что такое оператор «->» в C ++?

-> не оператор. Фактически это два отдельных оператора - и>.
Код условия уменьшает x, возвращая исходное (не уменьшенное) значение x, а затем сравнивает исходное значение с 0 с помощью оператора>.
Чтобы лучше понять, заявление можно было бы записать следующим образом:
а ((x--)> 0)
|
Или что-то совсем другое ... x скатывается до 0.
а (х - \
\
\
\
> 0)
printf ("% d", x);
Не так уж и математически, но ... каждая картинка рисует тысячу слов ...
|
Это очень сложный оператор, поэтому даже ISO / IEC JTC1 (Объединенный технический комитет 1) разместил его описание в двух разных частях стандарта C ++.
Помимо шуток, это два разных оператора: - и>, описанные соответственно в §5.2.6 / 2 и §5.9 стандарта C ++ 03.
|
Это эквивалентно
в то время как (x--> 0)
x-- (пост-декремент) эквивалентен x = x-1, поэтому код преобразуется в:
while (x> 0) {
х = х-1;
// логика
}
Икс--; // Пост-декремент выполняется, когда x <= 0
|
x может стремиться к нулю даже быстрее в обратном направлении:
int x = 10;
в то время как (0 <---- x)
{
printf ("% d", x);
}
8 6 4 2
Вы можете контролировать скорость с помощью стрелки!
int x = 100;
пока (0 <-------------------- x)
{
printf ("% d", x);
}
90 80 70 60 50 40 30 20 10
;)
|
Это
#include 
int main (void) {
int x = 10;
while (x--> 0) {// x переходит в 0
printf ("% d", x);
}
возврат 0;
}
Просто пробел заставляет вещи выглядеть забавно, - уменьшает и> сравнивает.
|
Использование -> имеет историческое значение. Уменьшение было (и все еще в некоторых случаях) быстрее, чем увеличение на архитектуре x86. Использование -> предполагает, что x стремится к 0, и обращается к тем, кто имеет математический опыт.
|
в то время как (x--> 0)
как это разбирается.
|
Совершенно чудаковатый, но я буду использовать это:
# определить как; пока
int main (int argc, char * argv [])
{
int n = atoi (argv [1]);
do printf ("n is% d \ n", n) as (n -> 0);
возврат 0;
}
|
В одной книге, которую я прочитал (я не помню правильно, в какой книге) сказано: Компиляторы пытаются анализировать выражения до самого большого токена, используя правило левого и правого.
В этом случае выражение:
х -> 0
Разбирает самые большие токены:
токен 1: x
токен 2: -
токен 3:>
токен 4: 0
сделать вывод: x--> 0
То же правило применяется к этому выражению:
а ----- б
После разбора:
токен 1: а
токен 2: -
токен 3: -
токен 4: -
токен 5: b
сделать вывод: (а -) - - б
Надеюсь, это поможет понять сложное выражение ^^
|
Это точно так же, как
в то время как (x--)
{
printf ("% d", x);
}
для неотрицательных чисел
|
Во всяком случае, у нас есть оператор "переходит к". «->» легко запомнить как направление, а «пока x стремится к нулю» - прямое значение.
Более того, на некоторых платформах это немного эффективнее, чем «for (x = 10; x> 0; x -)».
|
Этот код сначала сравнивает x и 0, а затем уменьшает x. (Также сказано в первом ответе: вы уменьшаете x, а затем сравниваете x и 0 с помощью оператора>.) См. Вывод этого кода:
9 8 7 6 5 4 3 2 1 0
Теперь мы сначала сравниваем, а затем уменьшаем, увидев на выходе 0.
Если мы хотим сначала уменьшить, а затем сравнить, используйте этот код:
#include 
int main (пусто)
{
int x = 10;
while (--x> 0) // x переходит в 0
{
printf ("% d", x);
}
возврат 0;
}
Этот вывод:
9 8 7 6 5 4 3 2 1
|
Когда я запускаю этот код, мой компилятор распечатает 9876543210.
#include 
int main ()
{
int x = 10;
while (x -> 0) // x переходит в 0
{
std :: cout << x;
}
}
Как и ожидалось. While (x--> 0) на самом деле означает while (x> 0). Пост x-- уменьшает x.
в то время как (x> 0)
{
Икс--;
std :: cout << x;
}
это другой способ записать одно и то же.
Приятно, что оригинал выглядит как «пока x идет в 0».
|
Между - и> отсутствует пробел. x уменьшается пост-декрементом, то есть уменьшается после проверки условия x> 0?.
|
- это оператор декремента, а> - оператор больше.
Эти два оператора применяются как один, например ->.
|
Это комбинация двух операторов. Первый - для уменьшения значения, а> - для проверки, больше ли значение правого операнда.
#include 
int main ()
{
int x = 10;
в то время как (x--> 0)
printf ("% d", x);
возврат 0;
}
Результат будет:
9 8 7 6 5 4 3 2 1 0
|
Фактически, x является постдекрементным и с этим условием проверяется. Это не ->, это (x--)> 0
Примечание: значение x изменяется после проверки условия, потому что оно уменьшается после уменьшения. Также могут возникать некоторые подобные случаи, например:
-> х -> 0
++> х ++> 0
-> = х -> = 0
++> = х ++> = 0
|
C и C ++ подчиняются правилу «максимального количества еды». Таким же образом a --- b переводится в (a-) - b, в вашем случае x -> 0 переводится в (x -)> 0.
По сути, правило гласит, что при движении слева направо выражения формируются путем взятия максимального количества символов, которые образуют допустимое выражение.
|
К чему все сложности?
Простой ответ на исходный вопрос:
#include 
int main ()
{
int x = 10;
в то время как (x>0)
{
printf ("% d", x);
х = х-1;
}
}
То же самое. Я не говорю, что вы должны делать это так, но он делает то же самое и ответил бы на вопрос в одном посте.
X-- - это просто сокращение для вышеупомянутого, а> - просто обычный оператор больше чем. Нет большой загадки!
В наши дни слишком много людей усложняют простые вещи;)
|
Обычным способом мы определяем условие в круглых скобках цикла while () и условие завершения внутри фигурных скобок {}, но -> определяет оба сразу.
Например:
int abc (пусто)
{
int a = 5
while ((a--)> 0) // Уменьшаем и сравниваем одновременно
{
// Код
}
}
Это уменьшает a и запускает цикл, пока a больше 0.
Условно это было бы так:
int abc (пусто)
{
int a = 5;
а (а> 0)
{
а-;
// Код
}
а-;
}
В обоих случаях мы делаем одно и то же и достигаем одних и тех же целей.
|
(x -> 0) означает (x -> 0).
Вы можете использовать (x ->) Вывод: 9 8 7 6 5 4 3 2 1 0
Вы можете использовать (- x> 0) Это означает (--x> 0) Вывод: 9 8 7 6 5 4 3 2 1
Ты можешь использовать
(- \
\
х> 0)
Выход: 9 8 7 6 5 4 3 2 1
Ты можешь использовать
(\
\
х -> 0)
Выход: 9 8 7 6 5 4 3 2 1 0
Ты можешь использовать
(\
\
х -> 0
\
\
)
Выход: 9 8 7 6 5 4 3 2 1 0
Вы также можете использовать
(
Икс
->
)
Выход: 9 8 7 6 5 4 3 2 1 0
Точно так же вы можете попробовать множество методов для успешного выполнения этой команды.
|
Здесь - унарный оператор пост декремента.
while (x--> 0) // x переходит в 0
{
printf ("% d", x);
}
Вначале условие будет оцениваться как
(x> 0) // 10> 0
Теперь, поскольку условие истинно, он войдет в цикл с уменьшенным значением
х-- // х = 9
Вот почему первое напечатанное значение - 9.
И так далее. В последнем цикле x = 1, значит, условие выполняется. Согласно унарному оператору, значение изменилось на x = 0 во время печати.
Теперь x = 0, что оценивает условие (x> 0) как ложное, и цикл while завершается.
|
Это -> вообще не оператор. У нас есть оператор вроде ->, но не вроде ->. Это просто неправильная интерпретация while (x--> 0), которая просто означает, что x имеет оператор пост-декремента, и этот цикл будет выполняться до тех пор, пока он не станет больше нуля.
Другой простой способ написать этот код - while (x--). Цикл while будет останавливаться всякий раз, когда возникает ложное условие, и здесь есть только один случай, т.е. 0. Таким образом, он остановится, когда значение x уменьшится до нуля.
|
Весьма активный вопрос. Заработайте 10 репутации, чтобы ответить на этот вопрос. Требование репутации помогает защитить этот вопрос от спама и отсутствия ответов.
Не тот ответ, который вы ищете? Просмотрите другие вопросы с метками c ++ операторы c соответствие стандартам форматирования кода или задайте свой вопрос.